package de.mnit.basis.daten;

import de.mnit.basis.fehler.Fehler;

/**
 * @author Michael Nitsche
 */
public class FilterText {

	public static String kuerzeDoppelte(char z, String t) {
		Fehler.objekt.wenn_Null(t);
		StringBuffer sb=new StringBuffer();
		char letztes=0;
		char[] tca=t.toCharArray();
		for(char c : tca) {
			if(!(c==letztes && letztes==z))
				sb.append(c);
			letztes=c;
		}
		return sb.toString();
	}

	public static String nur(char[] zeichen, String text) {
		Fehler.objekt.wenn_Null(zeichen,text);
		StringBuffer sb=new StringBuffer();
		char[] text_za=text.toCharArray();
		String zeichen_s=new String(zeichen);
		for(char text_z : text_za)
			if(zeichen_s.indexOf(text_z)>=0) sb.append(text_z);
		return sb.toString();
	}

	public static String nicht(char[] zeichen, String text) {
		Fehler.objekt.wenn_Null(zeichen,text);
		StringBuffer sb=new StringBuffer();
		char[] text_za=text.toCharArray();
		String zeichen_s=new String(zeichen);
		for(char text_z : text_za)
			if(zeichen_s.indexOf(text_z)<0) sb.append(text_z);
		return sb.toString();
	}

	public static String teil(int von, int laenge_rechts, String t) {
		Fehler.objekt.wenn_Null(t);
		Fehler.zahl.wenn_Null(von);
		if(von<0) Fehler.zahl.wenn_ZuGross(-von, laenge_rechts);
		if(von>0) Fehler.zahl.wenn_ZuKlein(-von, laenge_rechts);
		Fehler.text.wenn_ZuKurz(Math.abs(von),t);
		if(von<0) Fehler.text.wenn_ZuKurz(-von + -laenge_rechts - (laenge_rechts==0 ? 0 : 1), t);
		if(von>0) Fehler.text.wenn_ZuKurz( von +  laenge_rechts - (laenge_rechts==0 ? 0 : 1), t);

		int von1 = von<0? t.length()+von+1 :von;
		int bis1 = von1+laenge_rechts+(laenge_rechts<0?+1:-1);

		if(laenge_rechts== 0)
			return "";
		return t.substring(bis1<von1? bis1-1 :von1-1, bis1<von1? von1 :bis1);
	}

	public static String teil(int von, boolean nach_links, String text) {
		Fehler.objekt.wenn_Null(text);
		Fehler.zahl.wenn_Null(von);
		Fehler.text.wenn_ZuKurz(Math.abs(von),text);

		int von1 = von<0 ? text.length()+von+1 : von;
		if(nach_links)
			return text.substring(0, von1 );
		else
			return text.substring( von1-1 );
	}

	public static char zeichen(int pos, String text) {
		Fehler.text.wenn_Null_o_Leer(text);
		Fehler.zahl.wenn_Ausserhalb(text.length(),pos);
		return pos<0 ? text.charAt(text.length()+pos) : text.charAt(pos-1);
	}

	public static String bis(char[] zeichen, boolean letztes, String t) {
		Fehler.objekt.wenn_Null(zeichen,t);
		Fehler.zahl.wenn_ZuKlein(1, zeichen.length);
		String zeichen2=new String(zeichen);
		if(letztes) {
			for(int p=t.length()-1; p>=0; p--)
				if(zeichen2.indexOf(t.charAt(p))>-1)
					return teil(p+1,true,t);
		}
		else
			for(int p=0; p<=t.length()-1; p++)
				if(zeichen2.indexOf(t.charAt(p))>-1)
					return teil(p+1,true,t);
		return t;
	}

	public static String bis(String text, boolean letztes, String t) {
		Fehler.objekt.wenn_Null(text,t);
		Fehler.text.wenn_Null_o_Leer(text);
		if(letztes) {
			for(int p=t.length()-1; p>=0; p--)
				if(t.indexOf(text,p)>-1)
					return teil(p+text.length(),true,t);
		}
		else {
			int i=t.indexOf(text);
			if(i>=0)
				return teil(i+text.length(),true,t);
		}
		return t;
	}

	public static String ab(String text, boolean letztes, String t) {
		Fehler.objekt.wenn_Null(text,t);
		Fehler.zahl.wenn_ZuKlein(1, text.length());
		if(letztes) {
			int start=0;
			int pos=-1;
			int tmp=-1;
			boolean min1=false;
			while((tmp=t.indexOf(text, start))>-1) {
				min1=true;
				pos = tmp;
				start=tmp+1;
			}
			return min1==false ? t : teil(pos+1,false,t);
		}
		else {
			int pos=t.indexOf(text);
			return pos<0 ? t : teil(pos+1,false,t);
		}
	}

	public static String trimme(String s, char[] zeichen, boolean links, boolean rechts) {
		String zs=new String(zeichen);
		if(links)
			while(s.length()>0 && zs.indexOf(s.charAt(0))>=0)
				s=s.substring(1);
		if(rechts)
			while(s.length()>0 && zs.indexOf(s.charAt(s.length()-1))>=0)
				s=s.substring(0, s.length()-1);
		return s;
	}

	public static String trimmeZuASCII(String s) {
		Fehler.objekt.wenn_Null(s);
		String erg="";
		for(char c : s.toCharArray())
			if(c<256) erg+=c;
		return erg;
	}

	public static String trimme(String s) {
		Fehler.objekt.wenn_Null(s);
		return s.trim();
	}

	public static String ersetze(String das, String durch, String in) {
		Fehler.objekt.wenn_Null(das,durch,in);
		return in.replaceAll("\\Q"+das+"\\E", durch);
	}

	public static String zwischen(String links, String rechts, String text) {
		return zwischen(links, rechts, 1, text);
	}

	public static String zwischen(String links, String rechts, int nr, String text) {
		int nr_pos=0;
		int start=-1;
		while(nr_pos<nr) {
			start=text.indexOf(links, start+1);
			if(start==-1) break;
			nr_pos++;
		}
		start+=links.length();
		int ende=text.indexOf(rechts, start);
		if(ende==-1)
			ende=text.length();
		return text.substring(start, ende);
	}

	public static String begrenzen(int max_laenge, String wert) {
		return wert.length()>max_laenge
			? FilterText.teil(max_laenge, true, wert)
			: wert;
	}

}
